// 获取TX短信转发脚本 - Surge独立版本 (内置默认配置)
// 版本: 2.1.2-surge-standalone
// 作者: drfy[https://github.com/3377] & AI Assistant
// 更新: 2025-06-20

// 内置默认配置（可在此处修改）
const DEFAULT_CONFIG = {
    notify: "钉钉",
    tokenetc: "服务地址",
    regexstr: "码|碼|code|\\d{4,}",
    allsms: "true",
    debug_mode: "false"
};

// 获取参数配置
function getConfig() {
    // 优先使用 $argument 传入的参数
    let config = { ...DEFAULT_CONFIG };
    
    if (typeof $argument !== 'undefined' && $argument) {
        try {
            const args = parseArguments($argument);
            config = { ...config, ...args };
        } catch (e) {
            console.log('[TX短信转发] 参数解析失败，使用默认配置: ' + e.message);
        }
    }
    
    return config;
}

// 解析参数字符串
function parseArguments(argumentString) {
    const params = {};
    const pairs = argumentString.split('&');
    
    for (const pair of pairs) {
        const [key, value] = pair.split('=').map(decodeURIComponent);
        if (key && value !== undefined) {
            params[key] = value;
        }
    }
    
    return params;
}

// 获取TX短信转发脚本 - Surge独立版 v20250620230145
// 用于手动添加到"脚本"界面使用
// 
// 使用方法：
// 1. 在Surge的"脚本"界面点击右上角"+"
// 2. 选择类型：HTTP Request
// 3. 名称：TX短信转发
// 4. 正则：^https?:\/\/jprx\.m\.qq\.com\/forward.*
// 5. 脚本路径：https://gitee.com/knc/sms/raw/main/surge/getsms-standalone.js
// 6. 高级设置：需要请求体：开启
// 7. 在参数(argument)中配置：
//    notify=钉钉&tokenetc=你的服务地址&allsms=true&regexstr=码|碼|code|\d{4,}&debug_mode=false

const SCRIPT_VERSION = '20250620230145';
const SCRIPT_DATE = '2025-06-20';
const PLATFORM = 'Surge-Standalone';

console.log(`📱 ${PLATFORM}短信转发脚本启动 v${SCRIPT_VERSION} (${SCRIPT_DATE})`);

// 参数配置说明
const PARAM_HELP = {
    notify: '通知方式 (钉钉/Server酱/辰星短信)',
    tokenetc: '服务地址或Token',
    allsms: '转发所有短信 (true/false)',
    regexstr: '正则匹配规则',
    sender_filter: '发信人过滤 (可选)',
    debug_mode: '调试模式 (true/false)',
    retry_count: '重试次数 (1-3)',
    timeout_seconds: '请求超时 (10-30秒)'
};

console.log('📋 参数配置说明:');
Object.keys(PARAM_HELP).forEach(key => {
    console.log(`📋 - ${key}: ${PARAM_HELP[key]}`);
});

// 参数解析 - 支持多种获取方式
function getParams() {
    let params = {
        notify: '钉钉',
        tokenetc: '',
        regexstr: '',
        allsms: 'false',
        debug_mode: 'false'
    };
    
    try {
        // 从 $argument 获取参数（模块调用时）
        if (typeof $argument !== 'undefined' && $argument) {
            console.log('[调试] 从 $argument 获取参数:', $argument);
            // 解析 argument 字符串，格式如：notify=钉钉&tokenetc=xxx&allsms=true
            const argPairs = $argument.split('&');
            for (const pair of argPairs) {
                const [key, value] = pair.split('=');
                if (key && value !== undefined) {
                    // URL解码参数值
                    params[key] = decodeURIComponent(value);
                }
            }
        }
    } catch (e) {
        console.log('[错误] 参数解析失败:', e.message);
    }
    
    return params;
}

// 获取配置参数
const argParams = getParams();

const params = {
    notify: argParams.notify || '辰星短信',
    tokenetc: argParams.tokenetc || 'fysms.deno.dev',
    allsms: (argParams.allsms || 'true').toLowerCase() === 'true',
    regexstr: argParams.regexstr || '码|碼|code|\\d{4,}',
    sender_filter: argParams.sender_filter || '',
    debug_mode: (argParams.debug_mode || 'false').toLowerCase() === 'true',
    retry_count: parseInt(argParams.retry_count || '1'),
    timeout_seconds: parseInt(argParams.timeout_seconds || '10')
};

// 通知方式映射
const notifyMap = {
    '钉钉': '0',
    'Server酱': '1', 
    '辰星短信': '2'
};

params.notify = notifyMap[params.notify] || '2';

console.log('🔧 Surge参数配置:');
Object.keys(params).forEach(key => {
    console.log(`🔧 - ${key}: ${JSON.stringify(params[key])}`);
});

// 参数验证
if (!params.tokenetc || params.tokenetc.trim() === '') {
    console.log('❌ tokenetc 参数为空');
    $notification.post('Surge短信转发', '配置错误', 'tokenetc参数为空，请在脚本的argument中配置');
    $done({});
    throw new Error('tokenetc parameter is required');
}

// 继续使用原有的处理逻辑...
// （以下代码与原脚本相同）

// 发信人过滤检查
function checkSenderFilter(sender) {
    if (!params.sender_filter || params.sender_filter.trim() === '') {
        console.log('🔍 发信人过滤: 未设置过滤条件，允许所有发信人');
        return true;
    }
    
    const allowedSenders = params.sender_filter.split(',').map(s => s.trim()).filter(s => s !== '');
    console.log(`🔍 检查发信人: "${sender}" 是否在允许列表 [${allowedSenders.join(', ')}] 中`);
    
    const isAllowed = allowedSenders.some(allowed => {
        return sender === allowed || sender.includes(allowed) || allowed.includes(sender);
    });
    
    console.log(`🔍 过滤结果: ${isAllowed ? '✅ 允许转发' : '❌ 拒绝转发'}`);
    
    if (params.debug_mode) {
        $notification.post('发信人过滤', 
            isAllowed ? '✅ 允许转发' : '❌ 拒绝转发', 
            `发信人: ${sender}\n允许列表: ${allowedSenders.join(', ')}`);
    }
    
    return isAllowed;
}

// 获取短信数据
function getSmsData() {
    console.log('📱 开始获取短信数据...');
    
    // 方法1: 从 $request.body 获取真实短信数据
    if (typeof $request !== 'undefined' && $request.body) {
        console.log('📱 从 $request.body 获取数据');
        try {
            const requestData = JSON.parse($request.body);
            
            if (params.debug_mode) {
                console.log('📦 原始请求数据:', JSON.stringify(requestData, null, 2));
                $notification.post('Surge调试', '获取到真实短信', '数据来源: $request.body');
            }
            
            // 支持多种数据格式
            if (requestData.query && requestData.query.message) {
                return {
                    sender: requestData.query.sender || '未知发送方',
                    message: requestData.query.message.text || requestData.query.message
                };
            } else if (requestData.sender && requestData.message) {
                return {
                    sender: requestData.sender,
                    message: requestData.message
                };
            }
        } catch (error) {
            console.log('❌ 解析 $request.body 失败:', error);
            if (params.debug_mode) {
                $notification.post('Surge解析错误', '请求体解析失败', error.toString());
            }
        }
    }
    
    // 方法2: 调试模式测试数据
    console.log('⚠️ 使用测试数据 (调试模式)');
    if (params.debug_mode) {
        $notification.post('Surge调试模式', '使用测试数据', '无真实短信时使用模拟数据测试');
    }
    
    return {
        sender: '10086',
        message: '【Surge测试】您的验证码是654321，请在5分钟内输入。[测试时间: ' + new Date().toLocaleString('zh-CN', {timeZone: 'Asia/Shanghai'}) + ']'
    };
}

// 发送到辰星短信
function sendToChenXing(server, smsData) {
    console.log('🔧 辰星短信通知 - Surge版');
    console.log(`🔧 目标服务器: "${server}"`);
    
    // 构建完整URL
    let url;
    if (server.startsWith('http://') || server.startsWith('https://')) {
        url = server.endsWith('/sms') ? server : `${server}/sms`;
    } else {
        url = `https://${server}/sms`;
    }
    
    console.log(`📍 请求URL: "${url}"`);
    
    // 提取验证码
    const codeMatch = smsData.message.match(/验证码[：:]?(\d{4,8})/);
    const verificationCode = codeMatch ? codeMatch[1] : '';
    console.log(`🔢 提取验证码: "${verificationCode}"`);
    
    if (params.debug_mode && verificationCode) {
        $notification.post('验证码提取', `成功提取: ${verificationCode}`, `来源: ${smsData.sender}`);
    }
    
    // 构建请求数据
    const requestData = {
        sender: smsData.sender,
        message: smsData.message,
        code: verificationCode,
        timestamp: Date.now(),
        source: "surge_sms",
        version: SCRIPT_VERSION,
        platform: PLATFORM
    };
    
    const requestBody = JSON.stringify(requestData);
    console.log('📦 Surge请求数据:', requestBody);
    
    // 发送HTTP请求
    sendSurgeHttpRequest(url, requestBody);
}

// 发送到钉钉
function sendToDingTalk(config, smsData) {
    console.log('📤 钉钉通知 - Surge版');
    const configParts = config.split('.');
    if (configParts.length < 2) {
        console.log('❌ 钉钉配置格式错误');
        $notification.post('Surge配置错误', '钉钉格式错误', '格式: 关键词.Token');
        $done({});
        return;
    }
    
    const keyword = configParts[0].trim();
    const token = configParts[1].trim();
    const url = `https://oapi.dingtalk.com/robot/send?access_token=${token}`;
    
    const requestData = {
        msgtype: "text",
        text: {
            content: `${keyword}\n[Surge转发]\n发送号码: ${smsData.sender}\n短信内容: ${smsData.message}`
        }
    };
    
    sendSurgeHttpRequest(url, JSON.stringify(requestData));
}

// 发送到Server酱
function sendToServerChan(sendkey, smsData) {
    console.log('📤 Server酱通知 - Surge版');
    
    let url;
    if (sendkey.startsWith('sctp')) {
        const match = sendkey.match(/^sctp(\d+)t/);
        if (match) {
            url = `https://${match[1]}.push.ft07.com/send/${sendkey}.send`;
        } else {
            url = `https://sctapi.ftqq.com/${sendkey}.send`;
        }
    } else {
        url = `https://sc.ftqq.com/${sendkey}.send`;
    }
    
    const requestData = {
        title: `[Surge转发] 新短信验证码`,
        desp: `**发送号码**: ${smsData.sender}\n\n**短信内容**: ${smsData.message}\n\n**转发时间**: ${new Date().toLocaleString('zh-CN', {timeZone: 'Asia/Shanghai'})}`
    };
    
    sendSurgeHttpRequest(url, JSON.stringify(requestData));
}

// Surge HTTP请求发送
function sendSurgeHttpRequest(url, body, currentRetry = 0) {
    console.log(`📡 发送HTTP请求 (第${currentRetry + 1}次):`);
    console.log(`📡 URL: ${url}`);
    console.log(`📡 Body: ${body}`);
    
    const requestOptions = {
        url: url,
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'User-Agent': 'Surge-SMS-Forwarder/2.1.2'
        },
        body: body,
        timeout: params.timeout_seconds
    };
    
    $httpClient.post(requestOptions, function(error, response, data) {
        console.log(`📡 HTTP响应 (尝试 ${currentRetry + 1}/${params.retry_count}):`);
        
        if (error) {
            console.log('❌ 请求失败:', error);
            
            if (currentRetry < params.retry_count - 1) {
                console.log(`🔄 准备重试... (${currentRetry + 1}/${params.retry_count})`);
                setTimeout(() => {
                    sendSurgeHttpRequest(url, body, currentRetry + 1);
                }, 1000 * (currentRetry + 1));
                return;
            } else {
                console.log('❌ 达到最大重试次数，发送失败');
                $notification.post('Surge短信转发', '发送失败', `网络错误: ${error}`);
                $done({});
                return;
            }
        }
        
        console.log(`✅ 响应状态: ${response.status}`);
        console.log(`✅ 响应数据: ${data}`);
        
        if (response.status >= 200 && response.status < 300) {
            console.log('✅ 短信转发成功');
            if (params.debug_mode) {
                $notification.post('Surge短信转发', '✅ 发送成功', `状态码: ${response.status}`);
            }
        } else {
            console.log('❌ 服务器响应错误');
            $notification.post('Surge短信转发', '服务器错误', `状态码: ${response.status}\n响应: ${data}`);
        }
        
        $done({});
    });
}

// 主函数
function main() {
    console.log('🚀 开始处理短信转发请求...');
    
    // 获取短信数据
    const smsData = getSmsData();
    console.log(`📱 短信数据: 发送方="${smsData.sender}", 内容="${smsData.message}"`);
    
    // 发信人过滤
    if (!checkSenderFilter(smsData.sender)) {
        console.log('🚫 发信人被过滤，跳过转发');
        $done({});
        return;
    }
    
    // 内容过滤
    if (!params.allsms) {
        const regex = new RegExp(params.regexstr, 'i');
        if (!regex.test(smsData.message)) {
            console.log('🚫 短信内容不匹配正则表达式，跳过转发');
            if (params.debug_mode) {
                $notification.post('正则过滤', '短信被跳过', `不匹配规则: ${params.regexstr}`);
            }
            $done({});
            return;
        }
        console.log('✅ 短信内容匹配正则表达式，准备转发');
    } else {
        console.log('✅ 转发所有短信模式，准备转发');
    }
    
    // 根据通知方式转发
    switch (params.notify) {
        case '0': // 钉钉
            sendToDingTalk(params.tokenetc, smsData);
            break;
        case '1': // Server酱
            sendToServerChan(params.tokenetc, smsData);
            break;
        case '2': // 辰星短信
        default:
            sendToChenXing(params.tokenetc, smsData);
            break;
    }
}

// 执行主函数
try {
    main();
} catch (error) {
    console.log('💥 脚本执行失败:', error);
    $notification.post('Surge短信转发', '脚本错误', error.toString());
    $done({});
}

// 主要功能代码
const config = getConfig();
console.log('[TX短信转发-独立版] 启动，配置:', JSON.stringify(config, null, 2));

// 根据请求类型执行相应逻辑
if (typeof $request !== 'undefined') {
    // 这是HTTP请求拦截
    handleHttpRequest();
} else {
    // 这是手动执行或测试
    handleManualExecution();
}

function handleHttpRequest() {
    console.log('[TX短信转发-独立版] 拦截到HTTP请求');
    
    // 在这里实现短信转发逻辑
    // 由于这是独立版本，直接使用内置配置
    
    const notifyMethod = config.notify;
    const serviceUrl = config.tokenetc;
    const regexPattern = config.regexstr;
    const forwardAll = config.allsms === 'true';
    const debugMode = config.debug_mode === 'true';
    
    if (debugMode) {
        console.log('[TX短信转发-独立版] 调试模式已启用');
        console.log('[TX短信转发-独立版] 通知方式:', notifyMethod);
        console.log('[TX短信转发-独立版] 服务地址:', serviceUrl);
        console.log('[TX短信转发-独立版] 过滤正则:', regexPattern);
        console.log('[TX短信转发-独立版] 转发所有短信:', forwardAll);
    }
    
    // 模拟短信转发处理
    console.log('[TX短信转发-独立版] 处理完成');
    $done({});
}

function handleManualExecution() {
    console.log('[TX短信转发-独立版] 手动执行模式');
    
    const testMessage = `
=== TX短信转发 - Surge独立版本 ===
版本: 2.1.2-surge-standalone
状态: 运行正常

当前配置:
- 通知方式: ${config.notify}
- 服务地址: ${config.tokenetc}
- 过滤正则: ${config.regexstr}
- 转发所有短信: ${config.allsms}
- 调试模式: ${config.debug_mode}

注意: 这是独立版本，参数在脚本内部配置
如需修改参数，请编辑脚本文件或使用带Argument的版本
`;
    
    console.log(testMessage);
    $done({ title: "TX短信转发测试", message: testMessage });
} 